{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "24c88602",
   "metadata": {},
   "source": [
    "## SAC-v1_Pendulum-v1\n",
    "\n",
    "SAC（Soft Actor-Critic）有两个版本，其中[SAC-v1](https://arxiv.org/abs/1801.01290)由Haarnoja等人于2018年提出，也是该算法的最初版本, [SAC-v2](https://arxiv.org/abs/1812.05905)则是于2019年提出的改进版本。其中相比于v1版本，SAC-v2主要做了两项重要改进，一是移除了Value网络，二是引入了自动调节entropy系数 $\\alpha$。\n",
    "\n",
    "由于目前主流使用的是V2版本，但为了方便读者学习，本Notebook会实现v1版本，其他SAC的Notebook则默认使用v2版本。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b892e72",
   "metadata": {},
   "source": [
    "### 定义参数\n",
    "\n",
    "为方便实验调试，把所有参数都放在一起"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c11c4d5d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "\n",
    "class Config:\n",
    "    def __init__(self):\n",
    "        self.algo_name = 'SAC'\n",
    "        self.env_id = 'Pendulum-v1'\n",
    "        self.mode = 'train'\n",
    "        self.seed = 0 # 随机种子\n",
    "        self.max_epsiode = 100 # 训练的回合数\n",
    "        self.max_step = 200 # 每个回合的最大步数，超过该数则游戏强制终止\n",
    "        #region 在线测试相关参数\n",
    "        self.online_eval_episode = 10 # 测试的回合数\n",
    "        self.online_eval_freq = 2000 # 在线测试的频率, 模型每更新N次就测试一次\n",
    "        #endregion\n",
    "        self.gamma = 0.99 #折扣因子\n",
    "        self.lambda_mean=1e-3 # 重参数化分布均值的损失权重\n",
    "        self.lambda_std=1e-3 # 重参数化分布标准差的损失权重\n",
    "        self.lambda_z = 0.0 # 重参数化分布抽样值的损失权重\n",
    "        self.soft_update_tau = 1e-2 # 目标网络软更新系数\n",
    "        self.lr_value  = 3e-4 # 值网络的学习率\n",
    "        self.lr_critic = 3e-4 # Q网络的学习率\n",
    "        self.lr_actor = 3e-4 # 策略网络的学习率\n",
    "        self.buffer_size = 100000 # 经验回放池大小\n",
    "        self.hidden_dim = 256 # 隐藏层维度\n",
    "        self.batch_size  = 128 # 批次大小\n",
    "        self.device = self._auto_get_device() # 设备\n",
    "    \n",
    "    def _auto_get_device(self):\n",
    "        _device = 'cpu'\n",
    "        if torch.cuda.is_available():\n",
    "            _device = 'cuda'\n",
    "        elif torch.backends.mps.is_available():\n",
    "            _device = 'mps'\n",
    "        return _device"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "377edc7d",
   "metadata": {},
   "source": [
    "### 定义模型\n",
    "\n",
    "SAC-v1版本包含三种网络，即Value网络、SoftQ网络(作为Critic)和Actor网络。与一般的Actor-Critic算法不同，这里多出的 `Value` 网络（即 $ V(s)$ 网络）主要有辅助训练SoftQ的。在 SAC v1 中，Q 网络的目标是：\n",
    "\n",
    "$$\n",
    "\\text{Q target} = r + \\gamma \\cdot V(s')\n",
    "$$\n",
    "\n",
    "因此从辅助Critic角度来看，其作用有：\n",
    "\n",
    "- 用 `V(s')` 代替 `min(Q₁, Q₂)` 来构造 Q 网络的训练目标；\n",
    "- 提供一个相对稳定的 bootstrapping 目标；\n",
    "- 避免 Q 网络过早依赖策略输出的新动作。\n",
    "\n",
    "另外 `Value` 网络学习的是当前策略下的 **soft value**：\n",
    "\n",
    "$$\n",
    "V(s) \\approx \\mathbb{E}_{a \\sim \\pi} \\left[ Q(s, a) - \\alpha \\log \\pi(a|s) \\right]\n",
    "$$\n",
    "\n",
    "`Value` 网络的损失函数为：\n",
    "\n",
    "$$\n",
    "\\mathcal{L}_V = \\mathbb{E}_{s \\sim D} \\left[ \\frac{1}{2} \\left( V(s) - \\mathbb{E}_{a \\sim \\pi} [Q(s,a) - \\alpha \\log \\pi(a|s)] \\right)^2 \\right]\n",
    "$$\n",
    "\n",
    "从辅助Actor角度，`Value` 网络学的是“当前策略”下的soft value。\n",
    "\n",
    "总而言之，Value` 网络既用来提供训练 SoftQ网络(Critic)的目标值，也参与Actor的soft value设计，相当于 Actor 和 Critic 网络训练之间的桥梁。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6218efae",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.optim import Adam\n",
    "from torch.distributions import Normal\n",
    "import numpy as np\n",
    "\n",
    "class ValueNet(nn.Module):\n",
    "    def __init__(self, state_dim, hidden_dim, init_w=3e-3):\n",
    "        super(ValueNet, self).__init__()\n",
    "        '''定义值网络\n",
    "        '''\n",
    "        self.linear1 = nn.Linear(state_dim, hidden_dim) # 输入层\n",
    "        self.linear2 = nn.Linear(hidden_dim, hidden_dim) # 隐藏层\n",
    "        self.linear3 = nn.Linear(hidden_dim, 1)\n",
    "\n",
    "        self.linear3.weight.data.uniform_(-init_w, init_w) # 初始化权重\n",
    "        self.linear3.bias.data.uniform_(-init_w, init_w)\n",
    "        \n",
    "    def forward(self, state):\n",
    "        x = F.relu(self.linear1(state))\n",
    "        x = F.relu(self.linear2(x))\n",
    "        x = self.linear3(x)\n",
    "        return x\n",
    "        \n",
    "        \n",
    "class Critic(nn.Module):\n",
    "    def __init__(self, state_dim, action_dim, hidden_dim, init_w=3e-3):\n",
    "        super(Critic, self).__init__()\n",
    "        '''SoftQ\n",
    "        '''\n",
    "        self.linear1 = nn.Linear(state_dim + action_dim, hidden_dim)\n",
    "        self.linear2 = nn.Linear(hidden_dim, hidden_dim)\n",
    "        self.linear3 = nn.Linear(hidden_dim, 1)\n",
    "        \n",
    "        self.linear3.weight.data.uniform_(-init_w, init_w)\n",
    "        self.linear3.bias.data.uniform_(-init_w, init_w)\n",
    "        \n",
    "    def forward(self, state, action):\n",
    "        x = torch.cat([state, action], 1)\n",
    "        x = F.relu(self.linear1(x))\n",
    "        x = F.relu(self.linear2(x))\n",
    "        x = self.linear3(x)\n",
    "        return x\n",
    "        \n",
    "        \n",
    "class Actor(nn.Module):\n",
    "    def __init__(self, state_dim, action_dim, hidden_dim, init_w=3e-3, log_std_min=-20, log_std_max=2):\n",
    "        super(Actor, self).__init__()\n",
    "        self.log_std_min = log_std_min\n",
    "        self.log_std_max = log_std_max\n",
    "        \n",
    "        self.linear1 = nn.Linear(state_dim, hidden_dim)\n",
    "        self.linear2 = nn.Linear(hidden_dim, hidden_dim)\n",
    "        \n",
    "        # 初始化权重\n",
    "        self.mean_linear = nn.Linear(hidden_dim, action_dim)\n",
    "        self.mean_linear.weight.data.uniform_(-init_w, init_w)\n",
    "        self.mean_linear.bias.data.uniform_(-init_w, init_w)\n",
    "        \n",
    "        self.log_std_linear = nn.Linear(hidden_dim, action_dim)\n",
    "        self.log_std_linear.weight.data.uniform_(-init_w, init_w)\n",
    "        self.log_std_linear.bias.data.uniform_(-init_w, init_w)\n",
    "        \n",
    "    def forward(self, state):\n",
    "        x = F.relu(self.linear1(state))\n",
    "        x = F.relu(self.linear2(x))\n",
    "        \n",
    "        mean    = self.mean_linear(x)\n",
    "        log_std = self.log_std_linear(x)\n",
    "        log_std = torch.clamp(log_std, self.log_std_min, self.log_std_max)\n",
    "        \n",
    "        return mean, log_std\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "debce530",
   "metadata": {},
   "source": [
    "### 定义经验回放\n",
    "\n",
    "经验回放主要有两个功能，一是存储样本(push)，二是随时采样样本(sample)。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1c740ca0",
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import deque\n",
    "import random\n",
    "\n",
    "class ReplayBuffer(object):\n",
    "    def __init__(self, cfg: Config) -> None:\n",
    "        self.capacity = cfg.buffer_size\n",
    "        self.buffer = deque(maxlen=self.capacity)\n",
    "        \n",
    "    def push(self, transitions):\n",
    "        ''' 存储transition到经验回放中\n",
    "        '''\n",
    "        self.buffer.append(transitions)\n",
    "\n",
    "    def sample(self, batch_size: int, sequential: bool = False):\n",
    "        if batch_size > len(self.buffer): # 如果批量大小大于经验回放的容量，则取经验回放的容量\n",
    "            batch_size = len(self.buffer)\n",
    "        if sequential: # 顺序采样\n",
    "            rand = random.randint(0, len(self.buffer) - batch_size)\n",
    "            batch = [self.buffer[i] for i in range(rand, rand + batch_size)]\n",
    "            return zip(*batch)\n",
    "        else: # 随机采样\n",
    "            batch = random.sample(self.buffer, batch_size)\n",
    "            return zip(*batch)\n",
    "        \n",
    "    def __len__(self):\n",
    "        ''' 返回当前存储的量\n",
    "        '''\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32a65b71",
   "metadata": {},
   "source": [
    "### 定义策略\n",
    "\n",
    "SAC-v1 的value网络包含主网络和目标网络，起作用跟`DQN`中的 $Q$ 和 $Q_target$ 网络是一样的，都是为了避免估计目标Q值的剧烈波动，使得训练更加稳定。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a86f725",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Policy:\n",
    "    def __init__(self, cfg: Config, state_dim:int, action_dim:int) -> None:\n",
    "\n",
    "        self.batch_size  = cfg.batch_size \n",
    "        \n",
    "        self.device = torch.device(cfg.device)\n",
    "        self.gamma = cfg.gamma\n",
    "        self.lambda_mean = cfg.lambda_mean\n",
    "        self.lambda_std  = cfg.lambda_std\n",
    "        self.lambda_z    = cfg.lambda_z\n",
    "        self.soft_update_tau = cfg.soft_update_tau\n",
    "\n",
    "        self.value_net  = ValueNet(state_dim, cfg.hidden_dim).to(self.device)\n",
    "        self.value_net_target = ValueNet(state_dim, cfg.hidden_dim).to(self.device)\n",
    "        self.value_net_target.load_state_dict(self.value_net.state_dict())\n",
    "        # for target_param, param in zip(self.value_net_target.parameters(), self.value_net.parameters()):\n",
    "        #     target_param.data.copy_(param.data)\n",
    "        self.critic = Critic(state_dim, action_dim, cfg.hidden_dim).to(self.device)\n",
    "        self.actor = Actor(state_dim, action_dim, cfg.hidden_dim).to(self.device)  \n",
    "\n",
    "        self.opt_value  = Adam(self.value_net.parameters(), lr=cfg.lr_value)\n",
    "        self.opt_critic = Adam(self.critic.parameters(), lr=cfg.lr_critic)\n",
    "        self.opt_actor = Adam(self.actor.parameters(), lr=cfg.lr_actor)  \n",
    "\n",
    "        self.memory = ReplayBuffer(cfg)\n",
    "\n",
    "        self.update_cnt = 0\n",
    "\n",
    "    def sample_action(self, state):\n",
    "        return self.predict_action(state)\n",
    "    \n",
    "    @torch.no_grad()\n",
    "    def predict_action(self, state):\n",
    "        state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "        mean, log_std = self.actor.forward(state)\n",
    "        std = log_std.exp()\n",
    "        dist = Normal(mean, std)\n",
    "        z = dist.sample()\n",
    "        action = torch.tanh(z)\n",
    "        action = action.detach().cpu().numpy()\n",
    "        return action[0]\n",
    "    \n",
    "    def get_policy_params(self):\n",
    "        '''获取策略网络的参数\n",
    "        '''\n",
    "        return self.actor.parameters()\n",
    "    \n",
    "    def set_policy_params(self, params):\n",
    "        '''设置策略网络的参数\n",
    "        '''\n",
    "        for param, new_param in zip(self.actor.parameters(), params):\n",
    "            param.data.copy_(new_param.data)\n",
    "        \n",
    "    def update(self):\n",
    "        if len(self.memory) < self.batch_size: # 当经验回放中不满足一个批量时，不更新策略\n",
    "            return \n",
    "        states, actions, rewards, next_states, dones = self.memory.sample(self.batch_size) # 从经验回放中随机采样一个批量的转移(transition)\n",
    "        # 将数据转换为tensor\n",
    "        states = torch.tensor(np.array(states), device = self.device, dtype=torch.float) # [B, state_dim]\n",
    "        actions = torch.tensor(np.array(actions), device=self.device,  dtype = torch.float)  #  [B, 1]\n",
    "        rewards = torch.tensor(rewards, device=self.device, dtype=torch.float).unsqueeze(1)   # [B, 1]\n",
    "        next_states = torch.tensor(np.array(next_states), device=self.device, dtype=torch.float) # [batchB_size, state_dim]\n",
    "        dones = torch.tensor(np.float32(dones), device=self.device).unsqueeze(1)  # [batch_size,1]\n",
    "        \n",
    "        expected_q_value = self.critic(states, actions) #计算t时刻的状态-动作Q值\n",
    "        expected_value   = self.value_net(states) #计算t时刻的状态值\n",
    "\n",
    "        mean_new, log_std_new = self.actor(states) #计算t时刻的均值和标准差\n",
    "        log_std_new = log_std_new.exp() #计算t时刻的标准差\n",
    "        dist_new = Normal(mean_new, log_std_new) #计算t时刻的正态分布\n",
    "        z = dist_new.sample() #计算t时刻的正态分布抽样\n",
    "        actions_new = torch.tanh(z) #计算t时刻的动作\n",
    "        log_prob_new = dist_new.log_prob(z) - torch.log(1 - actions_new.pow(2) + 1e-6) #计算t时刻的动作似然概率\n",
    "        log_prob_new = log_prob_new.sum(-1, keepdim=True)\n",
    "\n",
    "        target_value = self.value_net_target(next_states) #计算t+1时刻的状态值\n",
    "        next_q_value = rewards + (1 - dones) * self.gamma * target_value # 时序差分计算t+1时刻的Q值\n",
    "        # JQ = 𝔼(st,at)~D[0.5(Q1(st,at) - r(st,at) - γ(𝔼st+1~p[V(st+1)]))^2]\n",
    "        loss_critic = nn.MSELoss()(expected_q_value, next_q_value.detach()) #计算q网络的损失函数\n",
    "\n",
    "        expected_new_q_value = self.critic(states, actions_new) #计算t时刻动作对应的q值\n",
    "        next_value = expected_new_q_value - log_prob_new # 计算t时刻的v值\n",
    "        loss_value = nn.MSELoss()(expected_value, next_value.detach()) #计算值网络损失函数\n",
    "        \n",
    "        ## 计算策略损失\n",
    "        log_prob_target = expected_new_q_value - expected_value \n",
    "        # Jπ = 𝔼st∼D,εt∼N[α * logπ(f(εt;st)|st) − Q(st,f(εt;st))]\n",
    "        loss_actor = (log_prob_new * (log_prob_new - log_prob_target).detach()).mean()\n",
    "\n",
    "        ## 计算reparameterization参数损失\n",
    "        mean_loss = self.lambda_mean * mean_new.pow(2).mean()\n",
    "        std_loss  = self.lambda_std  * log_std_new.pow(2).mean()\n",
    "        z_loss    = self.lambda_z    * z.pow(2).sum(1).mean()\n",
    "\n",
    "        loss_actor += mean_loss + std_loss + z_loss\n",
    "\n",
    "        self.opt_critic.zero_grad()\n",
    "        loss_critic.backward()\n",
    "        self.opt_critic.step()\n",
    "\n",
    "        self.opt_value.zero_grad()\n",
    "        loss_value.backward()\n",
    "        self.opt_value.step()\n",
    "\n",
    "        self.opt_actor.zero_grad()\n",
    "        loss_actor.backward()\n",
    "        self.opt_actor.step()\n",
    "        ## 软更新目标值网络参数\n",
    "        for target_param, param in zip(self.value_net_target.parameters(), self.value_net.parameters()):\n",
    "            target_param.data.copy_(\n",
    "                target_param.data * (1.0 - self.soft_update_tau) + param.data * self.soft_update_tau\n",
    "            )\n",
    "        self.update_cnt += 1\n",
    "        return {'loss_critic': loss_critic.item(), 'loss_value': loss_value.item(), 'loss_actor': loss_actor.item()}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14e02ee1",
   "metadata": {},
   "source": [
    "### 定义可视化函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "81469728",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import os\n",
    "\n",
    "def smooth(data: list, weight: float = 0.9):\n",
    "    '''用于平滑曲线，类似于Tensorboard中的smooth曲线\n",
    "    '''\n",
    "    last = data[0] \n",
    "    smoothed = []\n",
    "    for point in data:\n",
    "        smoothed_val = last * weight + (1 - weight) * point  # 计算平滑值\n",
    "        smoothed.append(smoothed_val)                    \n",
    "        last = smoothed_val                                \n",
    "    return smoothed\n",
    "\n",
    "def plot_curve(cfg: Config, frames: list, rewards : list, label:str = \"rewards\", title:str = None):\n",
    "    ''' 画图\n",
    "    '''\n",
    "    if title is None:\n",
    "        title = f\"{cfg.mode}ing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_id}\"\n",
    "    sns.set_theme(style=\"darkgrid\")\n",
    "    plt.figure()  # 创建一个图形实例，方便同时多画几个图\n",
    "    plt.title(title)\n",
    "    plt.xlabel('frames')\n",
    "    plt.plot(frames, rewards, label=f\"{label}\")\n",
    "    plt.plot(frames, smooth(rewards), label=f\"{label}_smoothed\")\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "def print_cfgs(cfg: Config):\n",
    "    ''' 打印参数\n",
    "    '''\n",
    "    cfg_dict = vars(cfg)\n",
    "    print(\"Hyperparameters:\")\n",
    "    print(''.join(['=']*80))\n",
    "    tplt = \"{:^20}\\t{:^20}\\t{:^20}\"\n",
    "    print(tplt.format(\"Name\", \"Value\", \"Type\"))\n",
    "    allow_types = ['int', 'float', 'str', 'bool', 'list', 'dict']\n",
    "    for k,v in cfg_dict.items():\n",
    "        if v.__class__.__name__ == 'list':\n",
    "            v = str(v)\n",
    "        if v.__class__.__name__ not in allow_types:\n",
    "            continue\n",
    "        print(tplt.format(k,v,str(type(v))))   \n",
    "    print(''.join(['=']*80))\n",
    "\n",
    "def all_seed(seed: int = 0):\n",
    "    ''' 设置随机种子\n",
    "    '''\n",
    "    if seed == 0:\n",
    "        return\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    torch.manual_seed(seed) # config for CPU\n",
    "    torch.cuda.manual_seed(seed) # config for GPU\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n",
    "    # config for cudnn\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.enabled = False  \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7b4c87a",
   "metadata": {},
   "source": [
    "### 定义环境"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "92504308",
   "metadata": {},
   "outputs": [],
   "source": [
    "import gymnasium as gym\n",
    "\n",
    "class NormalizedActions(gym.ActionWrapper):\n",
    "    ''' 由于网络输出的动作范围是[-1, 1]，而环境接收的动作范围可能是[-2,2]这种非标准化的范围，所以需要对动作进行归一化\n",
    "        也可以在Policy中进行进行action的scale和bias，但是相对来说会麻烦些\n",
    "    '''\n",
    "    def action(self, action):\n",
    "        low  = self.action_space.low\n",
    "        high = self.action_space.high\n",
    "        \n",
    "        action = low + (action + 1.0) * 0.5 * (high - low)\n",
    "        action = np.clip(action, low, high)\n",
    "        \n",
    "        return action\n",
    "\n",
    "    def reverse_action(self, action):\n",
    "        low  = self.action_space.low\n",
    "        high = self.action_space.high\n",
    "        action = 2 * (action - low) / (high - low) - 1\n",
    "        action = np.clip(action, low, high)\n",
    "        return action\n",
    "    \n",
    "class EnvMgr:\n",
    "    def __init__(self, cfg: Config):\n",
    "        self.env = gym.make(cfg.env_id) # 创建环境\n",
    "        self.env = NormalizedActions(self.env) # 归一化动作空间\n",
    "        self.eval_env = gym.make(cfg.env_id)\n",
    "        self.eval_env = NormalizedActions(self.eval_env)\n",
    "        print(f\"env id: {cfg.env_id}, state_dim: {self.state_dim}, action_dim: {self.action_dim}\")\n",
    "    @property\n",
    "    def action_dim(self):\n",
    "        return self.env.action_space.shape[0] # 动作空间的维度\n",
    "    @property\n",
    "    def state_dim(self):\n",
    "        return self.env.observation_space.shape[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2581771",
   "metadata": {},
   "source": [
    "## 2.模型训练与测试"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "0a3e3413",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import gymnasium as gym\n",
    "\n",
    "\n",
    "def eval_policy(cfg: Config, policy: Policy, env):\n",
    "    ''' 测试\n",
    "    '''\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    steps = []  # 记录所有回合的步数\n",
    "    for i_ep in range(cfg.online_eval_episode):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        ep_step = 0\n",
    "        state, _ = env.reset(seed = cfg.seed)  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_step):\n",
    "            action = policy.predict_action(state)  # 选择动作\n",
    "            next_state, reward, terminated, truncated , _ = env.step(action)  # 更新环境，返回transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            ep_step += 1\n",
    "            if terminated or truncated:\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "        steps.append(ep_step)\n",
    "    \n",
    "    return {'reward': np.mean(rewards), 'step': np.mean(steps)}\n",
    "\n",
    "def train(cfg: Config, policy: Policy, env_mgr: EnvMgr):\n",
    "    ''' 训练\n",
    "    '''\n",
    "    env = env_mgr.env\n",
    "    eval_env = env_mgr.eval_env\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    eval_rewards = []  # 记录所有回合的奖励\n",
    "    best_policy_params = None  # 最佳策略\n",
    "    best_ep_reward = float('-inf') # 最佳回合的奖励\n",
    "    tot_step = 0\n",
    "    policy_summary_dict = {} # 记录策略更新的参数，如损失等\n",
    "    for i_ep in range(cfg.max_epsiode):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        ep_step = 0\n",
    "        state, _ = env.reset(seed = cfg.seed)  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_step):\n",
    "            ep_step += 1\n",
    "            tot_step += 1\n",
    "            action = policy.sample_action(state)  # 选择动作\n",
    "            next_state, reward, terminated, truncated , _ = env.step(action)  # 更新环境，返回transition\n",
    "            policy.memory.push((state, action, reward, next_state, terminated or truncated))  # 保存transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            # 更新智能体，这里也可以改成每采样50步再更新50次\n",
    "            policy_summary = policy.update()  \n",
    "            if policy_summary is not None:\n",
    "                for k, v in policy_summary.items():\n",
    "                    if k not in policy_summary_dict:\n",
    "                        policy_summary_dict[k] = []\n",
    "                    policy_summary_dict[k].append(v)\n",
    "                if policy.update_cnt > 0 and policy.update_cnt % cfg.online_eval_freq == 0:\n",
    "                    eval_res = eval_policy(cfg, policy, eval_env)\n",
    "                    eval_rewards.append(eval_res['reward'])\n",
    "                    if eval_res['reward'] >= best_ep_reward:\n",
    "                        print(f\"找到新的最优策略，回合：{i_ep+1}，模型步数：{policy.update_cnt}，测试奖励：{eval_res['reward']:.2f}, 测试回合长度：{eval_res['step']}\")\n",
    "                        best_ep_reward = eval_res['reward']\n",
    "                        best_policy_params = policy.get_policy_params()\n",
    "            # policy.update() \n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if terminated or truncated:\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "        if (i_ep + 1) % 10 == 0:\n",
    "            print(f\"回合：{i_ep+1}/{cfg.max_epsiode}，奖励：{ep_reward:.2f}，回合长度：{ep_step}\")\n",
    "    env.close()\n",
    "    return {'rewards':rewards, 'eval_rewards':eval_rewards, 'policy_summary_dict':policy_summary_dict,'best_policy_params':best_policy_params}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "4b4294aa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "env id: Pendulum-v1, state_dim: 3, action_dim: 1\n",
      "Hyperparameters:\n",
      "================================================================================\n",
      "        Name        \t       Value        \t        Type        \n",
      "     algo_name      \t        SAC         \t   <class 'str'>    \n",
      "       env_id       \t    Pendulum-v1     \t   <class 'str'>    \n",
      "        mode        \t       train        \t   <class 'str'>    \n",
      "        seed        \t         0          \t   <class 'int'>    \n",
      "    max_epsiode     \t        100         \t   <class 'int'>    \n",
      "      max_step      \t        200         \t   <class 'int'>    \n",
      "online_eval_episode \t         10         \t   <class 'int'>    \n",
      "  online_eval_freq  \t        2000        \t   <class 'int'>    \n",
      "       gamma        \t        0.99        \t  <class 'float'>   \n",
      "    lambda_mean     \t       0.001        \t  <class 'float'>   \n",
      "     lambda_std     \t       0.001        \t  <class 'float'>   \n",
      "      lambda_z      \t        0.0         \t  <class 'float'>   \n",
      "  soft_update_tau   \t        0.01        \t  <class 'float'>   \n",
      "      lr_value      \t       0.0003       \t  <class 'float'>   \n",
      "     lr_critic      \t       0.0003       \t  <class 'float'>   \n",
      "      lr_actor      \t       0.0003       \t  <class 'float'>   \n",
      "    buffer_size     \t       100000       \t   <class 'int'>    \n",
      "     hidden_dim     \t        256         \t   <class 'int'>    \n",
      "     batch_size     \t        128         \t   <class 'int'>    \n",
      "       device       \t        cuda        \t   <class 'str'>    \n",
      "================================================================================\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'Normal' object has no attribute 'log_prob_new'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[8], line 7\u001b[0m\n\u001b[0;32m      5\u001b[0m all_seed(cfg\u001b[38;5;241m.\u001b[39mseed)\n\u001b[0;32m      6\u001b[0m print_cfgs(cfg)\n\u001b[1;32m----> 7\u001b[0m res \u001b[38;5;241m=\u001b[39m \u001b[43mtrain\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcfg\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpolicy\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43menv_mgr\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;66;03m# 训练\u001b[39;00m\n",
      "Cell \u001b[1;32mIn[7], line 49\u001b[0m, in \u001b[0;36mtrain\u001b[1;34m(cfg, policy, env_mgr)\u001b[0m\n\u001b[0;32m     47\u001b[0m state \u001b[38;5;241m=\u001b[39m next_state  \u001b[38;5;66;03m# 更新下一个状态\u001b[39;00m\n\u001b[0;32m     48\u001b[0m \u001b[38;5;66;03m# 更新智能体，这里也可以改成每采样50步再更新50次\u001b[39;00m\n\u001b[1;32m---> 49\u001b[0m policy_summary \u001b[38;5;241m=\u001b[39m \u001b[43mpolicy\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mupdate\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m  \n\u001b[0;32m     50\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m policy_summary \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m     51\u001b[0m     \u001b[38;5;28;01mfor\u001b[39;00m k, v \u001b[38;5;129;01min\u001b[39;00m policy_summary\u001b[38;5;241m.\u001b[39mitems():\n",
      "Cell \u001b[1;32mIn[4], line 73\u001b[0m, in \u001b[0;36mPolicy.update\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m     71\u001b[0m z \u001b[38;5;241m=\u001b[39m dist_new\u001b[38;5;241m.\u001b[39msample() \u001b[38;5;66;03m#计算t时刻的正态分布抽样\u001b[39;00m\n\u001b[0;32m     72\u001b[0m actions_new \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mtanh(z) \u001b[38;5;66;03m#计算t时刻的动作\u001b[39;00m\n\u001b[1;32m---> 73\u001b[0m log_prob_new \u001b[38;5;241m=\u001b[39m \u001b[43mdist_new\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlog_prob_new\u001b[49m(z) \u001b[38;5;241m-\u001b[39m torch\u001b[38;5;241m.\u001b[39mlog(\u001b[38;5;241m1\u001b[39m \u001b[38;5;241m-\u001b[39m actions_new\u001b[38;5;241m.\u001b[39mpow(\u001b[38;5;241m2\u001b[39m) \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1e-6\u001b[39m) \u001b[38;5;66;03m#计算t时刻的动作似然概率\u001b[39;00m\n\u001b[0;32m     74\u001b[0m log_prob_new \u001b[38;5;241m=\u001b[39m log_prob_new\u001b[38;5;241m.\u001b[39msum(\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, keepdim\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[0;32m     76\u001b[0m target_value \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mvalue_net_target(next_states) \u001b[38;5;66;03m#计算t+1时刻的状态值\u001b[39;00m\n",
      "\u001b[1;31mAttributeError\u001b[0m: 'Normal' object has no attribute 'log_prob_new'"
     ]
    }
   ],
   "source": [
    "\n",
    "# 获取参数\n",
    "cfg = Config() \n",
    "env_mgr = EnvMgr(cfg) # 创建环境\n",
    "policy = Policy(cfg, env_mgr.state_dim, env_mgr.action_dim) # 创建策略\n",
    "all_seed(cfg.seed)\n",
    "print_cfgs(cfg)\n",
    "res = train(cfg, policy, env_mgr) # 训练\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bd90699a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_curve(cfg, range(len(res['rewards'])), res['rewards'], label = \"rewards\", title = f\"{cfg.mode}ing rewards on {cfg.device} of {cfg.algo_name} for {cfg.env_id}\")\n",
    "for k, v in res['policy_summary_dict'].items():\n",
    "    plot_curve(cfg, range(len(v)), v, label = k, title = f\"{cfg.mode}ing {k} on {cfg.device} of {cfg.algo_name} for {cfg.env_id}\")\n",
    "plot_curve(cfg, range(len(res['eval_rewards'])), res['eval_rewards'], label = \"eval_rewards\", title = f\"online eval reward on {cfg.device} of {cfg.algo_name} for {cfg.env_id}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "joyrl-book",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
